package org.qy.star_grpc.core_api;

import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.29.0)",
    comments = "Source: BrokerCoreApi.proto")
public final class BrokerCoreApiGrpc {

  private BrokerCoreApiGrpc() {}

  public static final String SERVICE_NAME = "org.qy.star_grpc.core_api.BrokerCoreApi";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserDeclareMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "userDeclare",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.User.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserDeclareMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserDeclareMethod;
    if ((getUserDeclareMethod = BrokerCoreApiGrpc.getUserDeclareMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getUserDeclareMethod = BrokerCoreApiGrpc.getUserDeclareMethod) == null) {
          BrokerCoreApiGrpc.getUserDeclareMethod = getUserDeclareMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.User, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "userDeclare"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.User.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("userDeclare"))
              .build();
        }
      }
    }
    return getUserDeclareMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserDeleteMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "userDelete",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.User.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserDeleteMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserDeleteMethod;
    if ((getUserDeleteMethod = BrokerCoreApiGrpc.getUserDeleteMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getUserDeleteMethod = BrokerCoreApiGrpc.getUserDeleteMethod) == null) {
          BrokerCoreApiGrpc.getUserDeleteMethod = getUserDeleteMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.User, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "userDelete"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.User.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("userDelete"))
              .build();
        }
      }
    }
    return getUserDeleteMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserUpdateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "userUpdate",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.User.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserUpdateMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.User, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUserUpdateMethod;
    if ((getUserUpdateMethod = BrokerCoreApiGrpc.getUserUpdateMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getUserUpdateMethod = BrokerCoreApiGrpc.getUserUpdateMethod) == null) {
          BrokerCoreApiGrpc.getUserUpdateMethod = getUserUpdateMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.User, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "userUpdate"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.User.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("userUpdate"))
              .build();
        }
      }
    }
    return getUserUpdateMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getVirtualHostDeclareMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "virtualHostDeclare",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getVirtualHostDeclareMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getVirtualHostDeclareMethod;
    if ((getVirtualHostDeclareMethod = BrokerCoreApiGrpc.getVirtualHostDeclareMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getVirtualHostDeclareMethod = BrokerCoreApiGrpc.getVirtualHostDeclareMethod) == null) {
          BrokerCoreApiGrpc.getVirtualHostDeclareMethod = getVirtualHostDeclareMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "virtualHostDeclare"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("virtualHostDeclare"))
              .build();
        }
      }
    }
    return getVirtualHostDeclareMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getVirtualHostDeleteMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "virtualHostDelete",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getVirtualHostDeleteMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getVirtualHostDeleteMethod;
    if ((getVirtualHostDeleteMethod = BrokerCoreApiGrpc.getVirtualHostDeleteMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getVirtualHostDeleteMethod = BrokerCoreApiGrpc.getVirtualHostDeleteMethod) == null) {
          BrokerCoreApiGrpc.getVirtualHostDeleteMethod = getVirtualHostDeleteMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "virtualHostDelete"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("virtualHostDelete"))
              .build();
        }
      }
    }
    return getVirtualHostDeleteMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getExchangeDeclareMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "exchangeDeclare",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getExchangeDeclareMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getExchangeDeclareMethod;
    if ((getExchangeDeclareMethod = BrokerCoreApiGrpc.getExchangeDeclareMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getExchangeDeclareMethod = BrokerCoreApiGrpc.getExchangeDeclareMethod) == null) {
          BrokerCoreApiGrpc.getExchangeDeclareMethod = getExchangeDeclareMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "exchangeDeclare"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("exchangeDeclare"))
              .build();
        }
      }
    }
    return getExchangeDeclareMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getExchangeDeleteMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "exchangeDelete",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getExchangeDeleteMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getExchangeDeleteMethod;
    if ((getExchangeDeleteMethod = BrokerCoreApiGrpc.getExchangeDeleteMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getExchangeDeleteMethod = BrokerCoreApiGrpc.getExchangeDeleteMethod) == null) {
          BrokerCoreApiGrpc.getExchangeDeleteMethod = getExchangeDeleteMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "exchangeDelete"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("exchangeDelete"))
              .build();
        }
      }
    }
    return getExchangeDeleteMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getQueueDeclareMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "queueDeclare",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getQueueDeclareMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getQueueDeclareMethod;
    if ((getQueueDeclareMethod = BrokerCoreApiGrpc.getQueueDeclareMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getQueueDeclareMethod = BrokerCoreApiGrpc.getQueueDeclareMethod) == null) {
          BrokerCoreApiGrpc.getQueueDeclareMethod = getQueueDeclareMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "queueDeclare"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("queueDeclare"))
              .build();
        }
      }
    }
    return getQueueDeclareMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getQueueDeleteMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "queueDelete",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getQueueDeleteMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getQueueDeleteMethod;
    if ((getQueueDeleteMethod = BrokerCoreApiGrpc.getQueueDeleteMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getQueueDeleteMethod = BrokerCoreApiGrpc.getQueueDeleteMethod) == null) {
          BrokerCoreApiGrpc.getQueueDeleteMethod = getQueueDeleteMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "queueDelete"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("queueDelete"))
              .build();
        }
      }
    }
    return getQueueDeleteMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getBindMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "bind",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getBindMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getBindMethod;
    if ((getBindMethod = BrokerCoreApiGrpc.getBindMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getBindMethod = BrokerCoreApiGrpc.getBindMethod) == null) {
          BrokerCoreApiGrpc.getBindMethod = getBindMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "bind"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("bind"))
              .build();
        }
      }
    }
    return getBindMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUnBindMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "unBind",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUnBindMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getUnBindMethod;
    if ((getUnBindMethod = BrokerCoreApiGrpc.getUnBindMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getUnBindMethod = BrokerCoreApiGrpc.getUnBindMethod) == null) {
          BrokerCoreApiGrpc.getUnBindMethod = getUnBindMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "unBind"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("unBind"))
              .build();
        }
      }
    }
    return getUnBindMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getPublishMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "publish",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getPublishMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getPublishMethod;
    if ((getPublishMethod = BrokerCoreApiGrpc.getPublishMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getPublishMethod = BrokerCoreApiGrpc.getPublishMethod) == null) {
          BrokerCoreApiGrpc.getPublishMethod = getPublishMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "publish"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("publish"))
              .build();
        }
      }
    }
    return getPublishMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.Message> getSubscribeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "subscribe",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.Message.class,
      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.Message> getSubscribeMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe, org.qy.star_grpc.core_api.BrokerCoreApiProto.Message> getSubscribeMethod;
    if ((getSubscribeMethod = BrokerCoreApiGrpc.getSubscribeMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getSubscribeMethod = BrokerCoreApiGrpc.getSubscribeMethod) == null) {
          BrokerCoreApiGrpc.getSubscribeMethod = getSubscribeMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe, org.qy.star_grpc.core_api.BrokerCoreApiProto.Message>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "subscribe"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.Message.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("subscribe"))
              .build();
        }
      }
    }
    return getSubscribeMethod;
  }

  private static volatile io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getAckMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ack",
      requestType = org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack.class,
      responseType = org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack,
      org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getAckMethod() {
    io.grpc.MethodDescriptor<org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> getAckMethod;
    if ((getAckMethod = BrokerCoreApiGrpc.getAckMethod) == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        if ((getAckMethod = BrokerCoreApiGrpc.getAckMethod) == null) {
          BrokerCoreApiGrpc.getAckMethod = getAckMethod =
              io.grpc.MethodDescriptor.<org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack, org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ack"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse.getDefaultInstance()))
              .setSchemaDescriptor(new BrokerCoreApiMethodDescriptorSupplier("ack"))
              .build();
        }
      }
    }
    return getAckMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static BrokerCoreApiStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<BrokerCoreApiStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<BrokerCoreApiStub>() {
        @java.lang.Override
        public BrokerCoreApiStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BrokerCoreApiStub(channel, callOptions);
        }
      };
    return BrokerCoreApiStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static BrokerCoreApiBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<BrokerCoreApiBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<BrokerCoreApiBlockingStub>() {
        @java.lang.Override
        public BrokerCoreApiBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BrokerCoreApiBlockingStub(channel, callOptions);
        }
      };
    return BrokerCoreApiBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static BrokerCoreApiFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<BrokerCoreApiFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<BrokerCoreApiFutureStub>() {
        @java.lang.Override
        public BrokerCoreApiFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BrokerCoreApiFutureStub(channel, callOptions);
        }
      };
    return BrokerCoreApiFutureStub.newStub(factory, channel);
  }

  /**
   */
  public static abstract class BrokerCoreApiImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     * 创建用户
     * </pre>
     */
    public void userDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getUserDeclareMethod(), responseObserver);
    }

    /**
     * <pre>
     * 删除用户
     * </pre>
     */
    public void userDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getUserDeleteMethod(), responseObserver);
    }

    /**
     * <pre>
     * 修改密码
     * </pre>
     */
    public void userUpdate(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getUserUpdateMethod(), responseObserver);
    }

    /**
     * <pre>
     * 创建虚拟主机
     * </pre>
     */
    public void virtualHostDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getVirtualHostDeclareMethod(), responseObserver);
    }

    /**
     * <pre>
     * 删除虚拟主机
     * </pre>
     */
    public void virtualHostDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getVirtualHostDeleteMethod(), responseObserver);
    }

    /**
     * <pre>
     * 创建交换机
     * </pre>
     */
    public void exchangeDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getExchangeDeclareMethod(), responseObserver);
    }

    /**
     * <pre>
     * 删除交换机
     * </pre>
     */
    public void exchangeDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getExchangeDeleteMethod(), responseObserver);
    }

    /**
     * <pre>
     * 创建队列
     * </pre>
     */
    public void queueDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getQueueDeclareMethod(), responseObserver);
    }

    /**
     * <pre>
     * 删除队列
     * </pre>
     */
    public void queueDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getQueueDeleteMethod(), responseObserver);
    }

    /**
     * <pre>
     * 绑定队列
     * </pre>
     */
    public void bind(org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getBindMethod(), responseObserver);
    }

    /**
     * <pre>
     * 解绑队列
     * </pre>
     */
    public void unBind(org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getUnBindMethod(), responseObserver);
    }

    /**
     * <pre>
     * 发布消息
     * </pre>
     */
    public void publish(org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getPublishMethod(), responseObserver);
    }

    /**
     * <pre>
     * 订阅消息
     * </pre>
     */
    public io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe> subscribe(
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.Message> responseObserver) {
      return asyncUnimplementedStreamingCall(getSubscribeMethod(), responseObserver);
    }

    /**
     * <pre>
     * 确认消息
     * </pre>
     */
    public void ack(org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getAckMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getUserDeclareMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_USER_DECLARE)))
          .addMethod(
            getUserDeleteMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_USER_DELETE)))
          .addMethod(
            getUserUpdateMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.User,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_USER_UPDATE)))
          .addMethod(
            getVirtualHostDeclareMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_VIRTUAL_HOST_DECLARE)))
          .addMethod(
            getVirtualHostDeleteMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_VIRTUAL_HOST_DELETE)))
          .addMethod(
            getExchangeDeclareMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_EXCHANGE_DECLARE)))
          .addMethod(
            getExchangeDeleteMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_EXCHANGE_DELETE)))
          .addMethod(
            getQueueDeclareMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_QUEUE_DECLARE)))
          .addMethod(
            getQueueDeleteMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_QUEUE_DELETE)))
          .addMethod(
            getBindMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_BIND)))
          .addMethod(
            getUnBindMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_UN_BIND)))
          .addMethod(
            getPublishMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_PUBLISH)))
          .addMethod(
            getSubscribeMethod(),
            asyncBidiStreamingCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.Message>(
                  this, METHODID_SUBSCRIBE)))
          .addMethod(
            getAckMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack,
                org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>(
                  this, METHODID_ACK)))
          .build();
    }
  }

  /**
   */
  public static final class BrokerCoreApiStub extends io.grpc.stub.AbstractAsyncStub<BrokerCoreApiStub> {
    private BrokerCoreApiStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BrokerCoreApiStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BrokerCoreApiStub(channel, callOptions);
    }

    /**
     * <pre>
     * 创建用户
     * </pre>
     */
    public void userDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getUserDeclareMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 删除用户
     * </pre>
     */
    public void userDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getUserDeleteMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 修改密码
     * </pre>
     */
    public void userUpdate(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getUserUpdateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 创建虚拟主机
     * </pre>
     */
    public void virtualHostDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getVirtualHostDeclareMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 删除虚拟主机
     * </pre>
     */
    public void virtualHostDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getVirtualHostDeleteMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 创建交换机
     * </pre>
     */
    public void exchangeDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getExchangeDeclareMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 删除交换机
     * </pre>
     */
    public void exchangeDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getExchangeDeleteMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 创建队列
     * </pre>
     */
    public void queueDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getQueueDeclareMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 删除队列
     * </pre>
     */
    public void queueDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getQueueDeleteMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 绑定队列
     * </pre>
     */
    public void bind(org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getBindMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 解绑队列
     * </pre>
     */
    public void unBind(org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getUnBindMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 发布消息
     * </pre>
     */
    public void publish(org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getPublishMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     * 订阅消息
     * </pre>
     */
    public io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.Subscribe> subscribe(
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.Message> responseObserver) {
      return asyncBidiStreamingCall(
          getChannel().newCall(getSubscribeMethod(), getCallOptions()), responseObserver);
    }

    /**
     * <pre>
     * 确认消息
     * </pre>
     */
    public void ack(org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack request,
        io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getAckMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class BrokerCoreApiBlockingStub extends io.grpc.stub.AbstractBlockingStub<BrokerCoreApiBlockingStub> {
    private BrokerCoreApiBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BrokerCoreApiBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BrokerCoreApiBlockingStub(channel, callOptions);
    }

    /**
     * <pre>
     * 创建用户
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse userDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request) {
      return blockingUnaryCall(
          getChannel(), getUserDeclareMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 删除用户
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse userDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request) {
      return blockingUnaryCall(
          getChannel(), getUserDeleteMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 修改密码
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse userUpdate(org.qy.star_grpc.core_api.BrokerCoreApiProto.User request) {
      return blockingUnaryCall(
          getChannel(), getUserUpdateMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 创建虚拟主机
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse virtualHostDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request) {
      return blockingUnaryCall(
          getChannel(), getVirtualHostDeclareMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 删除虚拟主机
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse virtualHostDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request) {
      return blockingUnaryCall(
          getChannel(), getVirtualHostDeleteMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 创建交换机
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse exchangeDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare request) {
      return blockingUnaryCall(
          getChannel(), getExchangeDeclareMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 删除交换机
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse exchangeDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete request) {
      return blockingUnaryCall(
          getChannel(), getExchangeDeleteMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 创建队列
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse queueDeclare(org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare request) {
      return blockingUnaryCall(
          getChannel(), getQueueDeclareMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 删除队列
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse queueDelete(org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete request) {
      return blockingUnaryCall(
          getChannel(), getQueueDeleteMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 绑定队列
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse bind(org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind request) {
      return blockingUnaryCall(
          getChannel(), getBindMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 解绑队列
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse unBind(org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind request) {
      return blockingUnaryCall(
          getChannel(), getUnBindMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 发布消息
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse publish(org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish request) {
      return blockingUnaryCall(
          getChannel(), getPublishMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     * 确认消息
     * </pre>
     */
    public org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse ack(org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack request) {
      return blockingUnaryCall(
          getChannel(), getAckMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class BrokerCoreApiFutureStub extends io.grpc.stub.AbstractFutureStub<BrokerCoreApiFutureStub> {
    private BrokerCoreApiFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BrokerCoreApiFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BrokerCoreApiFutureStub(channel, callOptions);
    }

    /**
     * <pre>
     * 创建用户
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> userDeclare(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.User request) {
      return futureUnaryCall(
          getChannel().newCall(getUserDeclareMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 删除用户
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> userDelete(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.User request) {
      return futureUnaryCall(
          getChannel().newCall(getUserDeleteMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 修改密码
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> userUpdate(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.User request) {
      return futureUnaryCall(
          getChannel().newCall(getUserUpdateMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 创建虚拟主机
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> virtualHostDeclare(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request) {
      return futureUnaryCall(
          getChannel().newCall(getVirtualHostDeclareMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 删除虚拟主机
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> virtualHostDelete(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost request) {
      return futureUnaryCall(
          getChannel().newCall(getVirtualHostDeleteMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 创建交换机
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> exchangeDeclare(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare request) {
      return futureUnaryCall(
          getChannel().newCall(getExchangeDeclareMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 删除交换机
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> exchangeDelete(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete request) {
      return futureUnaryCall(
          getChannel().newCall(getExchangeDeleteMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 创建队列
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> queueDeclare(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare request) {
      return futureUnaryCall(
          getChannel().newCall(getQueueDeclareMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 删除队列
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> queueDelete(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete request) {
      return futureUnaryCall(
          getChannel().newCall(getQueueDeleteMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 绑定队列
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> bind(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind request) {
      return futureUnaryCall(
          getChannel().newCall(getBindMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 解绑队列
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> unBind(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind request) {
      return futureUnaryCall(
          getChannel().newCall(getUnBindMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 发布消息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> publish(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish request) {
      return futureUnaryCall(
          getChannel().newCall(getPublishMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     * 确认消息
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse> ack(
        org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack request) {
      return futureUnaryCall(
          getChannel().newCall(getAckMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_USER_DECLARE = 0;
  private static final int METHODID_USER_DELETE = 1;
  private static final int METHODID_USER_UPDATE = 2;
  private static final int METHODID_VIRTUAL_HOST_DECLARE = 3;
  private static final int METHODID_VIRTUAL_HOST_DELETE = 4;
  private static final int METHODID_EXCHANGE_DECLARE = 5;
  private static final int METHODID_EXCHANGE_DELETE = 6;
  private static final int METHODID_QUEUE_DECLARE = 7;
  private static final int METHODID_QUEUE_DELETE = 8;
  private static final int METHODID_BIND = 9;
  private static final int METHODID_UN_BIND = 10;
  private static final int METHODID_PUBLISH = 11;
  private static final int METHODID_ACK = 12;
  private static final int METHODID_SUBSCRIBE = 13;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final BrokerCoreApiImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(BrokerCoreApiImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_USER_DECLARE:
          serviceImpl.userDeclare((org.qy.star_grpc.core_api.BrokerCoreApiProto.User) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_USER_DELETE:
          serviceImpl.userDelete((org.qy.star_grpc.core_api.BrokerCoreApiProto.User) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_USER_UPDATE:
          serviceImpl.userUpdate((org.qy.star_grpc.core_api.BrokerCoreApiProto.User) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_VIRTUAL_HOST_DECLARE:
          serviceImpl.virtualHostDeclare((org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_VIRTUAL_HOST_DELETE:
          serviceImpl.virtualHostDelete((org.qy.star_grpc.core_api.BrokerCoreApiProto.VirtualHost) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_EXCHANGE_DECLARE:
          serviceImpl.exchangeDeclare((org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDeclare) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_EXCHANGE_DELETE:
          serviceImpl.exchangeDelete((org.qy.star_grpc.core_api.BrokerCoreApiProto.ExchangeDelete) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_QUEUE_DECLARE:
          serviceImpl.queueDeclare((org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDeclare) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_QUEUE_DELETE:
          serviceImpl.queueDelete((org.qy.star_grpc.core_api.BrokerCoreApiProto.QueueDelete) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_BIND:
          serviceImpl.bind((org.qy.star_grpc.core_api.BrokerCoreApiProto.Bind) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_UN_BIND:
          serviceImpl.unBind((org.qy.star_grpc.core_api.BrokerCoreApiProto.UnBind) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_PUBLISH:
          serviceImpl.publish((org.qy.star_grpc.core_api.BrokerCoreApiProto.Publish) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        case METHODID_ACK:
          serviceImpl.ack((org.qy.star_grpc.core_api.BrokerCoreApiProto.Ack) request,
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.UnifiedResponse>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_SUBSCRIBE:
          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.subscribe(
              (io.grpc.stub.StreamObserver<org.qy.star_grpc.core_api.BrokerCoreApiProto.Message>) responseObserver);
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class BrokerCoreApiBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    BrokerCoreApiBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return org.qy.star_grpc.core_api.BrokerCoreApiProto.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("BrokerCoreApi");
    }
  }

  private static final class BrokerCoreApiFileDescriptorSupplier
      extends BrokerCoreApiBaseDescriptorSupplier {
    BrokerCoreApiFileDescriptorSupplier() {}
  }

  private static final class BrokerCoreApiMethodDescriptorSupplier
      extends BrokerCoreApiBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    BrokerCoreApiMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (BrokerCoreApiGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new BrokerCoreApiFileDescriptorSupplier())
              .addMethod(getUserDeclareMethod())
              .addMethod(getUserDeleteMethod())
              .addMethod(getUserUpdateMethod())
              .addMethod(getVirtualHostDeclareMethod())
              .addMethod(getVirtualHostDeleteMethod())
              .addMethod(getExchangeDeclareMethod())
              .addMethod(getExchangeDeleteMethod())
              .addMethod(getQueueDeclareMethod())
              .addMethod(getQueueDeleteMethod())
              .addMethod(getBindMethod())
              .addMethod(getUnBindMethod())
              .addMethod(getPublishMethod())
              .addMethod(getSubscribeMethod())
              .addMethod(getAckMethod())
              .build();
        }
      }
    }
    return result;
  }
}
